#include "Bsp.h"
#include "Oled_ui.h"


// 系统状态结构体
typedef struct {
    int selectedMode;   // 当前选择的模式
} SystemState;

SystemState systemState = {0}; // 全局系统状态变量


/* ========== 一级菜单函数 ========== */

/**
 * @brief 主菜单界面
 * @return 选择的菜单项编号
 */

static int OLED_UI(void) {
    const int MENU_ITEMS = 4;
    const int menu_items[][4] = {
        {0, 0, 64, 16},   // 模式选择
        {0, 16, 64, 16},  // 电池电量
        {0, 32, 64, 16},  // 陀螺仪
        {0, 48, 32, 16}   // 设置
    };
    
    int current = 1; // 当前选中项
    
    OLED_Clear();
    OLED_ShowChinese(0, 0, "模式选择");
    OLED_ShowChinese(0, 16, "电池电量");
    OLED_ShowChinese(0, 32, "陀螺仪");
    OLED_ShowChinese(0, 48, "设置");
    reverse_menu_item(menu_items[0][0], menu_items[0][1], 
                     menu_items[0][2], menu_items[0][3]);
    OLED_Update();

    while(1) {
        if(Key_scan() == 2) {
            reverse_menu_item(menu_items[current-1][0], 
                             menu_items[current-1][1], 
                             menu_items[current-1][2], 
                             menu_items[current-1][3]);
            
            current = (current % MENU_ITEMS) + 1;
            
            reverse_menu_item(menu_items[current-1][0], 
                             menu_items[current-1][1], 
                             menu_items[current-1][2], 
                             menu_items[current-1][3]);
            OLED_Update();
        }
        
        if(Key_scan() == 1) {
            OLED_Clear();
            OLED_Update();
            return current;
        }
    }
}

/* ========== 二级菜单函数 ========== */

/**
 * @brief 模式选择菜单
 * @return 0-返回主菜单（本函数实际不返回）
 */
static int ModeSelect_UI(void) 
{
    const int MENU_ITEMS = 4; // 模式数量
    const int menu_items[][4] = {
        {0, 0, 64, 16},   // 模式1
        {0, 16, 64, 16},  // 模式2
        {0, 32, 64, 16},  // 模式3
        {0, 48, 64, 16}   // 模式4
    };
    
    int current = 1; // 当前选中项
    
    // 显示模式选择菜单
    OLED_Clear();
    OLED_ShowChinese(0, 0, "模式一");
    OLED_ShowChinese(0, 16, "模式二");
    OLED_ShowChinese(0, 32, "模式三");
    OLED_ShowChinese(0, 48, "模式四");
    reverse_menu_item(menu_items[0][0], menu_items[0][1], 
                     menu_items[0][2], menu_items[0][3]);
    OLED_Update();

    while(1) {
        switch(Key_scan()) {
            case 2: // 切换模式
                // 清除当前反显
                reverse_menu_item(menu_items[current-1][0], 
                                 menu_items[current-1][1], 
                                 menu_items[current-1][2], 
                                 menu_items[current-1][3]);
                
                // 循环切换模式
                current = (current % MENU_ITEMS) + 1;
                
                // 应用新的反显区域
                reverse_menu_item(menu_items[current-1][0], 
                                 menu_items[current-1][1], 
                                 menu_items[current-1][2], 
                                 menu_items[current-1][3]);
                OLED_Update();
                break;
                
            case 1: // 确认选择
                // 进入模式运行界面
                ModeRun_UI(current);
                
                // 从模式运行返回后，重新显示菜单
                OLED_Clear();
                OLED_ShowChinese(0, 0, "模式一");
                OLED_ShowChinese(0, 16, "模式二");
                OLED_ShowChinese(0, 32, "模式三");
                OLED_ShowChinese(0, 48, "模式四");
                reverse_menu_item(menu_items[current-1][0], 
                                 menu_items[current-1][1], 
                                 menu_items[current-1][2], 
                                 menu_items[current-1][3]);
                OLED_Update();
                break;
        }
    }
    
    return 0; // 实际不会执行到此
}

/**
 * @brief 陀螺仪子菜单
 * @return 0-返回主菜单
 */
static int GyroMenu_UI(void) 
{
    const int MENU_ITEMS = 4;
    const int menu_items[][4] = {
        {0, 0, 64, 16},   // 角度
        {0, 16, 64, 16},  // 角加速度
        {0, 32, 64, 16},  // 加速度
        {0, 48, 32, 16}   // 返回
    };
    
    int current = 1; // 当前选中项
    
    OLED_Clear();
    OLED_ShowChinese(0, 0, "角度");
    OLED_ShowChinese(0, 16, "角加速度");
    OLED_ShowChinese(0, 32, "加速度");
    OLED_ShowChinese(0, 48, "返回");
    reverse_menu_item(menu_items[0][0], menu_items[0][1], 
                     menu_items[0][2], menu_items[0][3]);
    OLED_Update();

    while(1) {
        switch(Key_scan()) {
            case 2: // 切换选项
                reverse_menu_item(menu_items[current-1][0], 
                                 menu_items[current-1][1], 
                                 menu_items[current-1][2], 
                                 menu_items[current-1][3]);
                
                current = (current % MENU_ITEMS) + 1;
                
                reverse_menu_item(menu_items[current-1][0], 
                                 menu_items[current-1][1], 
                                 menu_items[current-1][2], 
                                 menu_items[current-1][3]);
                OLED_Update();
                break;
                
            case 1: // 确认选择
                if(current == 4) return 0;
                
                // 进入三级菜单
                void (*sensor_uis[])(void) = {
                    AngleData_UI, GyroData_UI, AccData_UI
                };
                sensor_uis[current-1]();
                
                // 返回后刷新菜单
                OLED_Clear();
                OLED_ShowChinese(0, 0, "角度");
                OLED_ShowChinese(0, 16, "角加速度");
                OLED_ShowChinese(0, 32, "加速度");
                OLED_ShowChinese(0, 48, "返回");
                reverse_menu_item(menu_items[current-1][0], 
                                 menu_items[current-1][1], 
                                 menu_items[current-1][2], 
                                 menu_items[current-1][3]);
                OLED_Update();
                break;
        }
    }
}


/**
 * @brief 电池电量显示界面
 * @return 0-返回主菜单
 */
static int Battery_UI(void) 
{

     // 显示电池信息
    OLED_Clear();
    OLED_ShowChinese(0, 0, "电池信息");
    OLED_ShowChinese(0, 16, "电压: ");
    OLED_ShowChinese(0, 32, "电量: ");
    OLED_ShowChinese(0, 48, "返回");
    while(1) 
    {
        // 获取ADC值
        adc_getValue();
        delay_cycles(3200000);
        adc_getValue();
        int bfb = (Adc.VDD / 12.6) * 100; // 计算电量百分比
        
        // 显示电池电压信息
        OLED_ShowFloatNum(40, 16, Adc.VDD, 2, 2, OLED_8X16);
        OLED_ShowNum(40, 32, bfb, 3, OLED_8X16);
        // 反显返回项
        //reverse_menu_item(0, 48, 32, 16);
        OLED_Update();
    
    
        if(Key_scan() == 1)
        {
            return 0; // 返回主菜单
        }
    }
}

/**
 * @brief 设置菜单
 * @return 0-返回主菜单，其他-设置项编号
 */
static int Settings_UI(void) 
{
    const int MENU_ITEMS = 4; // 设置项数量+返回
    const int menu_items[][4] = {
        {0, 0, 64, 16},   // 亮度调节
        {0, 16, 64, 16},  // 时间设置
        {0, 32, 64, 16},  // 恢复默认
        {0, 48, 32, 16}   // 返回
    };
    
    int current = 1; // 当前选中项
    int returnValue = 0; // 返回值
    
    // 显示设置菜单
    OLED_Clear();
    OLED_ShowChinese(0, 0, "亮度调节");
    OLED_ShowChinese(0, 16, "时间设置");
    OLED_ShowChinese(0, 32, "恢复默认");
    OLED_ShowChinese(0, 48, "返回");
    reverse_menu_item(menu_items[0][0], menu_items[0][1], 
                     menu_items[0][2], menu_items[0][3]);
    OLED_Update();

    while(1) {
        switch(Key_scan()) {
            case 2: // 切换选项
                reverse_menu_item(menu_items[current-1][0], 
                                 menu_items[current-1][1], 
                                 menu_items[current-1][2], 
                                 menu_items[current-1][3]);
                
                current = (current % MENU_ITEMS) + 1;
                
                reverse_menu_item(menu_items[current-1][0], 
                                 menu_items[current-1][1], 
                                 menu_items[current-1][2], 
                                 menu_items[current-1][3]);
                OLED_Update();
                break;
                
            case 1: // 确认选择
                if(current == 4) { // 返回项
                    return 0;
                }
                
                // 执行选中的设置项
                OLED_Clear();
                OLED_ShowChinese(0, 0, "设置项");
                OLED_ShowNum(0, 16, current, 2, OLED_8X16);
                OLED_Update();
                
                // 这里可以添加设置项执行代码
                // 例如：if(current == 1) BrightnessAdjust();
                
                // 设置执行完成后返回
                returnValue = current;
                
                // 重新显示菜单
                OLED_Clear();
                OLED_ShowChinese(0, 0, "亮度调节");
                OLED_ShowChinese(0, 16, "时间设置");
                OLED_ShowChinese(0, 32, "恢复默认");
                OLED_ShowChinese(0, 48, "返回");
                reverse_menu_item(menu_items[current-1][0], 
                                 menu_items[current-1][1], 
                                 menu_items[current-1][2], 
                                 menu_items[current-1][3]);
                OLED_Update();
                return returnValue;
        }
    }
}

/* ========== 三级菜单函数 ========== */

/**
 * @brief 角度数据显示界面
 */
static void AngleData_UI(void) 
{
    OLED_Clear();
    //OLED_ShowChinese(0, 0, "角度数据");
    
    while(1) {
        // 显示X/Y/Z轴角度数据
        OLED_ShowChinese(0, 0, "俯仰角");
        OLED_ShowFloatNum(48, 0,  SAngle.Angle[0], 2, 1, OLED_8X16);
        
        OLED_ShowChinese(0, 16, "翻滚角");
        OLED_ShowFloatNum(48, 16, SAngle.Angle[1], 3, 1, OLED_8X16);
        
        OLED_ShowChinese(0, 32, "偏航角");
        OLED_ShowFloatNum(48, 32, SAngle.Angle[2], 3, 1, OLED_8X16);
        
        OLED_ShowChinese(0, 48, "按确认返回");
        OLED_Update();
        delay_cycles(3200000);
        if(Key_scan() == 1) return; // 确认键退出
    }
}


/**
 * @brief 角加速度数据显示界面
 */
static void GyroData_UI(void) {
    OLED_Clear();
    OLED_ShowChinese(0, 0, "角加速度数据");
    
    while(1) {
        // 显示X/Y/Z轴角加速度数据
        OLED_ShowFloatNum(0, 16, SGyro.Gyro[0], 1, 2, OLED_8X16);
        
        OLED_ShowFloatNum(64, 16, SGyro.Gyro[1], 1, 2, OLED_8X16);
        
        OLED_ShowFloatNum(0, 32, SGyro.Gyro[2], 1, 2, OLED_8X16);
        
        OLED_ShowChinese(0, 48, "按确认返回");
        OLED_Update();
        
        if(Key_scan() == 1) return; // 确认键退出
    }
}

/**
 * @brief 加速度数据显示界面
 */
static void AccData_UI(void) 
{
    OLED_Clear();
    OLED_ShowChinese(0, 0, "加速度数据");
    
    while(1) {
        // 显示X/Y/Z轴加速度数据
        OLED_ShowFloatNum(0, 16, SAcc.Acc[0], 1, 2, OLED_8X16);
        
        OLED_ShowFloatNum(64, 16, SAcc.Acc[1], 1, 2, OLED_8X16);
        
        OLED_ShowFloatNum(0, 32, SAcc.Acc[2], 1, 2, OLED_8X16);
        
        OLED_ShowChinese(0, 48, "按确认返回");
        OLED_Update();
        
        if(Key_scan() == 1) return; // 确认键退出
   }
}

/**
 * @brief 模式运行界面
 * @param mode 选择的模式
 */
static void ModeRun_UI(int mode) 
{
    systemState.selectedMode = mode; // 记录选择的模式
    
    OLED_Clear();
    
    // 根据模式显示不同内容
    const char* modeTexts[] = {
        "模式一运行中",
        "模式二运行中",
        "模式三运行中",
        "模式四运行中"
    };
    
    if(mode >= 1 && mode <= 4) {
        OLED_ShowChinese(0, 0, modeTexts[mode-1]);
    }
    
    OLED_ShowChinese(0, 48, "按确认返回");
    OLED_Update();
    
    while(1) {
        if(Key_scan() == 1) {  // 按确认键返回
            return;
        }
        
        // 这里可以添加模式运行的实际功能代码
        // 例如：读取传感器、更新显示等
        // ...
    }
}


/* ========== 核心导航函数 ========== */

/**
 * @brief 菜单导航主循环
 */
void Menu_Navigation(void) 
{
    while(1) {
        switch(OLED_UI()) {
            case 1: while(ModeSelect_UI() != 0); break;
            case 2: while(Battery_UI() != 0); break;
            case 3: while(GyroMenu_UI() != 0); break;
            case 4: while(Settings_UI() != 0); break;
        }
    }
}

/**
 * @brief 区域反显辅助函数
 * @param x,y 起始坐标
 * @param width,height 区域尺寸
 */
void reverse_menu_item(int x, int y, int width, int height) 
{
    OLED_ReverseArea(x, y, width, height);
}

// 全局模式标志位（在文件顶部定义）
uint8_t g_current_mode = 0; // 0表示未选择模式

/* ========== 一级菜单函数 ========== */
int OLED_Pu(void) {
    int current = 1; // 当前模式（1-4）
    
    // 初始显示
    OLED_Clear();
    OLED_ShowChinese(0, 0, "模式");
    OLED_ShowFloatNum(0, 16, SAngle.Angle[2], 3, 1, OLED_8X16);
    OLED_ShowNum(32, 0, current, 1,OLED_8X16); // 显示当前模式数字
    OLED_Update();

    while(1) {
        uint8_t key = Key_scan();
        OLED_ShowFloatNum(0, 16, SAngle.Angle[2], 3, 1, OLED_8X16);
        OLED_Update();
        if(key == 1) { // KEY1按下 - 切换模式
            // 循环切换模式 (1->2->3->4->1)
            current = (current % 4) + 1;
            
            // 更新显示
            OLED_Clear();
            OLED_ShowChinese(0, 0, "模式");
            OLED_ShowNum(32, 0, current, 1,OLED_8X16);
            OLED_Update();
        }
        else if(key == 2) { // KEY2按下 - 确认选择或退出
            // 设置全局标志位
            g_current_mode = current;
            counter.count = 0 ;
            // 清除屏幕
            OLED_Update();
            
            // 返回选择的模式
            return current;
        }
        
    }
}